﻿using UnityEngine;

namespace Gj
{
    public enum HexDirectionColumn : byte
    {
        NE,
        E,
        SE,
        SW,
        W,
        NW // 东北  东 东南 西南  西  西北
    }

    public enum HexDirectionRow : byte
    {
        NE,
        SE,
        S,
        SW,
        NW,
        N // 东北  东南  南  西南  西北  北
    }

    public enum HexDirectionRowDouble : byte
    {
        NE,
        SE,
        S,
        SW,
        NW,
        N,
        NNE,
        E,
        SSE,
        SSW,
        W,
        NNW // 东北  东南  南  西南  西北  北
    }

    public enum HexDirectionRowColumn : byte
    {
        NE,
        E,
        SE,
        SW,
        W,
        NW // 东北  东 东南 西南  西  西北
    }

    public enum HexDirectionColumnRow : byte
    {
        NE,
        SE,
        S,
        SW,
        NW,
        N // 东北  东南  南  西南  西北  北
    }

    public static class HexDirectionExtensions
    {
        public static HexDirectionRow[] HexDirectionRows = new [] { HexDirectionRow.S, HexDirectionRow.SE, HexDirectionRow.NE, HexDirectionRow.N, HexDirectionRow.NW, HexDirectionRow.SW };

        public static HexDirectionRow GetOpposite(HexDirectionRow r)
        {
            switch (r)
            {
                case HexDirectionRow.S:
                    return HexDirectionRow.N;
                case HexDirectionRow.SW:
                    return HexDirectionRow.NE;
                case HexDirectionRow.NW:
                    return HexDirectionRow.SE;
                case HexDirectionRow.N:
                    return HexDirectionRow.S;
                case HexDirectionRow.NE:
                    return HexDirectionRow.SW;
                case HexDirectionRow.SE:
                    return HexDirectionRow.NW;
            }

            return HexDirectionRow.N;
        }

        public static readonly int[][][] ODDR =
        {
            new[]
            {
                new[] { 0, -1 }, new[] { 1, 0 }, new[] { 0, 1 }, new[] { -1, 1 }, new[] { -1, 0 }, new[] { -1, -1 }
            },
            new[]
            {
                new[] { 1, -1 }, new[] { 1, 0 }, new[] { 1, 1 }, new[] { 0, 1 }, new[] { -1, 0 }, new[] { 0, -1 }
            },

            new[]
            {
                new[] { 1, -1 }, new[] { 1, 1 }, new[] { 0, 2 }, new[] { -2, 1 }, new[] { -2, -1 }, new[] { 0, -2 }
            },
            new[]
            {
                new[] { 2, -1 }, new[] { 2, 1 }, new[] { 0, 2 }, new[] { -1, 1 }, new[] { -1, -1 }, new[] { 0, -2 }
            }
        };

        public static readonly int[][][] EVENR =
        {
            new[]
            {
                new[] { 1, -1 }, new[] { 1, 0 }, new[] { 1, 1 }, new[] { 0, 1 }, new[] { -1, 0 }, new[] { 0, -1 }
            },
            new[]
            {
                new[] { 0, -1 }, new[] { 1, 0 }, new[] { 0, 1 }, new[] { -1, 1 }, new[] { -1, 0 }, new[] { -1, -1 }
            },


            new[]
            {
                new[] { 2, -1 }, new[] { 2, 1 }, new[] { 0, 2 }, new[] { -1, 1 }, new[] { -1, -1 }, new[] { 0, -2 }
            },
            new[]
            {
                new[] { 1, -1 }, new[] { 1, 1 }, new[] { 0, 2 }, new[] { -2, 1 }, new[] { -2, -1 }, new[] { 0, -2 }
            }
        };

        public static readonly int[][][] ODDQ =
        {
            new[]
            {
                new[] { 1, -1 }, new[] { 1, 0 }, new[] { 0, 1 }, new[] { -1, 0 }, new[] { -1, -1 }, new[] { 0, -1 }
            },
            new[]
            {
                new[] { 1, 0 }, new[] { 1, 1 }, new[] { 0, 1 }, new[] { -1, 1 }, new[] { -1, 0 }, new[] { 0, -1 }
            },

            new[]
            {
                new[] { 1, -2 }, new[] { 2, 0 }, new[] { 1, 1 }, new[] { -1, 1 }, new[] { -2, 0 }, new[] { -1, -2 }
            },
            new[]
            {
                new[] { 1, -1 }, new[] { 2, 0 }, new[] { 1, 2 }, new[] { -1, 2 }, new[] { -2, 0 }, new[] { -1, -1 }
            }
        };

        public static readonly int[][][] EVENQ =
        {
            new[]
            {
                new[] { 1, 0 }, new[] { 1, 1 }, new[] { 0, 1 }, new[] { -1, 1 }, new[] { -1, 0 }, new[] { 0, -1 },
                new[] { 1, -1 }, new[] { 2, 0 }, new[] { 1, 2 }, new[] { -1, 2 }, new[] { -2, 0 }, new[] { -1, -1 }
            },
            new[]
            {
                new[] { 1, -1 }, new[] { 1, 0 }, new[] { 0, 1 }, new[] { -1, 0 }, new[] { -1, -1 }, new[] { 0, -1 },
                new[] { 1, -2 }, new[] { 2, 0 }, new[] { 1, 1 }, new[] { -1, 1 }, new[] { -2, 0 }, new[] { -1, -2 }
            },

            new[]
            {
                new[] { 1, -1 }, new[] { 2, 0 }, new[] { 1, 2 }, new[] { -1, 2 }, new[] { -2, 0 }, new[] { -1, -1 }
            },
            new[]
            {
                new[] { 1, -2 }, new[] { 2, 0 }, new[] { 1, 1 }, new[] { -1, 1 }, new[] { -2, 0 }, new[] { -1, -2 }
            }
        };

        public static readonly Vector2[] VERTEX =
        {
            new Vector2(0.66f, 0), new Vector2( 0.33f, 0.5f ), new Vector2( -0.33f, 0.5f ), new Vector2( -0.66f, 0 ), new Vector2( -0.33f, -0.5f ), new Vector2( 0.33f, -0.5f )
        };

        public static byte Offset(byte enter, byte export)
        {
            return (byte)((export - enter + 6) % 6);
        }

        public static byte OffsetDouble(byte enter, byte export)
        {
            return (byte)((export - enter + 12) % 12);
        }
    }
}